home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / CommandProcessor.C < prev    next >
C/C++ Source or Header  |  1992-06-30  |  5KB  |  253 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "CommandProcessor.h"
  6.  
  7. #include "Class.h"
  8. #include "ObjArray.h"
  9. #include "Menu.h"
  10. #include "CmdNo.h"
  11.  
  12. //---- CommandProcessor --------------------------------------------------------
  13.  
  14. NewMetaImpl(CommandProcessor,Object, (T(changeCount), T(cap)));
  15.  
  16. CommandProcessor::CommandProcessor()
  17. {
  18.     cap= changeCount= 0;
  19. }
  20.  
  21. CommandProcessor::~CommandProcessor()
  22. {
  23.     //if (changeCount > 0)
  24.     //    Error("~CommandProcessor", "changeCount > 0");
  25. }
  26.  
  27. Command *CommandProcessor::GetAt(int)
  28. {
  29.     return 0;
  30. }
  31.  
  32. void CommandProcessor::PerformCommand(Command* cmd)
  33. {
  34.     if (cmd == 0)
  35.     return;
  36.  
  37.     switch (cmd->GetType()) {
  38.  
  39.     case eCmdTypeCantUndo:
  40.     FinishFrom(0);
  41.     changeCount+= cmd->Perform();
  42.     cmd->Done(0);
  43.     cmd->Finish();
  44.     break;
  45.  
  46.     case eCmdTypeNoChange:
  47.     CommandProcessor::PerformNormalCommand(cmd);
  48.     break;
  49.  
  50.     case eCmdTypeNormal:
  51.     FinishFrom(changeCount);
  52.     PerformNormalCommand(cmd);
  53.     break;
  54.     }
  55. }
  56.  
  57. void CommandProcessor::PerformNormalCommand(Command* cmd)
  58. {
  59.     if (cmd) {
  60.     cmd->Perform();
  61.     cmd->Done(0);
  62.     cmd->Finish();
  63.     }
  64. }
  65.  
  66. void CommandProcessor::DoCreateMenu(Menu *menu)
  67. {
  68.     if (menu->GetId() == cEDITMENU) {
  69.     if (Size() <= 0)
  70.         menu->AppendItems("Can't undo2", cUNDO, 0);
  71.     else {
  72.         menu->AppendItem("Undo2@Z", cUNDO);
  73.         if (Size() >= 2)
  74.         menu->AppendItems("Redo2@Z", cREDO, 0);
  75.     }
  76.     }
  77. }
  78.  
  79. void CommandProcessor::DoSetupMenu(Menu *menu)
  80. {
  81.     if (menu->GetId() == cEDITMENU) {
  82.     Command *cmd;
  83.     
  84.     if (cmd= GetAt(changeCount-1)) {
  85.         menu->ReplaceItem(cUNDO, cmd->GetUndoName());
  86.         if (cmd->GetType() != eCmdTypeCantUndo)
  87.         menu->EnableItem(cUNDO);
  88.     } else {
  89.         menu->ReplaceItem(cUNDO, "Undo@Z");
  90.         menu->DisableItem(cUNDO);
  91.     }
  92.     
  93.     if (Size() >= 2) {
  94.         if (cmd= GetAt(changeCount)) {
  95.         menu->ReplaceItem(cREDO, cmd->GetUndoName());
  96.         menu->EnableItem(cREDO);
  97.         } else {
  98.         menu->ReplaceItem(cREDO, "Redo@Z");
  99.         menu->DisableItem(cREDO);
  100.         }
  101.     }
  102.     }
  103. }
  104.  
  105. void CommandProcessor::DoMenuCommand(int cmdId)
  106. {
  107.     Command *c;
  108.     
  109.     switch (cmdId) {
  110.     case cUNDO:
  111.     if (c= GetAt(changeCount-1))
  112.         changeCount+= c->Perform();
  113.     break;
  114.     case cREDO:
  115.     if (c= GetAt(changeCount))
  116.         changeCount+= c->Perform();
  117.     break;
  118.     }
  119. }
  120.  
  121. void CommandProcessor::Finish()
  122. {
  123.     FinishFrom(0);
  124.     changeCount= 0;
  125. }
  126.  
  127. void CommandProcessor::FinishFrom(int)
  128. {
  129. }
  130.  
  131. //---- CommandProcessor1 -------------------------------------------------------
  132.  
  133. NewMetaImpl(CommandProcessor1,CommandProcessor, (TP(lastCmd)));
  134.  
  135. CommandProcessor1::CommandProcessor1()
  136. {
  137.     lastCmd= 0;
  138.     cap= 1;
  139. }
  140.  
  141. Command *CommandProcessor1::GetAt(int)
  142. {
  143.     return lastCmd;
  144. }
  145.  
  146. void CommandProcessor1::PerformNormalCommand(Command* cmd)
  147. {
  148.     if (lastCmd)
  149.     lastCmd->Done(cmd);
  150.     lastCmd= cmd;
  151.     changeCount+= cmd->Perform();
  152. }
  153.  
  154. void CommandProcessor1::FinishFrom(int)
  155. {
  156.     if (lastCmd) {
  157.     lastCmd->Finish();
  158.     lastCmd= 0;
  159.     }
  160. }
  161.  
  162. //---- CommandProcessorN -------------------------------------------------------
  163.  
  164. NewMetaImpl(CommandProcessorN,CommandProcessor, (TP(cmdHistory)));
  165.  
  166. CommandProcessorN::CommandProcessorN()
  167. {
  168.     cmdHistory= new ObjArray;
  169.     cap= 99999;
  170. }
  171.  
  172. CommandProcessorN::~CommandProcessorN()
  173. {
  174.     SafeDelete(cmdHistory);
  175. }
  176.  
  177. Command *CommandProcessorN::GetAt(int i)
  178. {
  179.     if (i >= 0 && i < cmdHistory->Size())
  180.     return (Command*) cmdHistory->At(i);
  181.     return 0;
  182. }
  183.  
  184. void CommandProcessorN::PerformNormalCommand(Command* cmd)
  185. {
  186.     Command *lastcmd;
  187.     if (lastcmd= GetAt(changeCount-1))
  188.     lastcmd->Done(cmd);
  189.     cmdHistory->AtPutAndExpand(changeCount, cmd);
  190.     changeCount+= cmd->Perform();
  191. }
  192.  
  193. void CommandProcessorN::FinishFrom(int n)
  194. {
  195.     for (int i= n; i < cmdHistory->Size(); i++) {
  196.     Command *c= (Command*) cmdHistory->At(i);
  197.     if (c) {
  198.         c->Finish();
  199.         cmdHistory->RemoveAt(i);
  200.     }
  201.     }
  202. }
  203.  
  204. //---- CommandProcessor10 ------------------------------------------------------
  205.  
  206. NewMetaImpl(CommandProcessor10,CommandProcessor, (TVP(mem,cap), T(start), T(size)));
  207.  
  208. CommandProcessor10::CommandProcessor10(int s)
  209. {
  210.     cap= s;
  211.     mem= new Command* [cap];
  212.     size= start= 0;
  213. }
  214.  
  215. CommandProcessor10::~CommandProcessor10()
  216. {
  217.     SafeDelete(mem);
  218. }
  219.  
  220. Command *CommandProcessor10::GetAt(int i)
  221. {
  222.     if (i >= start && i < start+size)
  223.     return mem[i % size];
  224.     return 0;
  225. }
  226.  
  227. void CommandProcessor10::PerformNormalCommand(Command* cmd)
  228. {
  229.     Command *lastcmd;
  230.     if (size >= cap) {      // overflow
  231.     start++;
  232.     GetAt(changeCount)->Finish();
  233.     size--;
  234.     }
  235.     size++;
  236.     if (lastcmd= GetAt(changeCount-1))
  237.     lastcmd->Done(cmd);
  238.     mem[changeCount % size]= cmd;
  239.     changeCount+= cmd->Perform();
  240. }
  241.  
  242. void CommandProcessor10::FinishFrom(int n)
  243. {
  244.     Command *c;
  245.     
  246.     n= (n == 0) ? start : changeCount;
  247.     
  248.     for (int i= n; c= GetAt(i); i++)
  249.     c->Finish();
  250.     size-= (i-changeCount);
  251. }
  252.  
  253.